home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 October: Mac OS SDK / Dev.CD Oct 96 SDK / Dev.CD Oct 96 SDK2.toast / Development Kits (Disc 2) / OpenDoc / OpenDoc Development / Debugging Support / OpenDoc Source Code / UI / Undo.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-22  |  57.3 KB  |  2,053 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        Undo.cpp
  3.  
  4.     Contains:    Implementation for Undo class
  5.  
  6.     Owned by:    Nick Pilch
  7.  
  8.     Copyright:    © 1994 - 1996 by Apple Computer, Inc., all rights reserved.
  9.  
  10.     Change History (most recent first):
  11.  
  12.          <3>    .04.1996    NP        1316777: Partiall fix race condition with
  13.                                     the disposal notification process.
  14.         <24>     10/8/95    TJ        Fixes Recomended by Refball
  15.         <23>     9/11/95    NP        1272294: Messaging code cleanup.
  16.         <22>     8/26/95    TÇ        1274606 FB2: Patching Remarks
  17.         <21>     8/23/95    NP        1275237, 1267015: Support for aborting
  18.                                     transactions.
  19.         <20>     8/22/95    eeh        1276821:
  20.                                     kOpenDocShellSignature->kODShellSignature
  21.         <19>     8/16/95    NP        1275241: IDL Review. Remove unnecessary
  22.                                     overrides.
  23.         <18>     8/12/95    TÇ        1276806 Optimization: use kODFalse instead
  24.                                     of kODTrue in comparisons
  25.         <17>      8/7/95    NP        1269965: should be able to nest
  26.                                     transactions, 1269789: Transaction redo
  27.                                     incorrectly implemented.
  28.         <16>      8/3/95    RR        #1257260: Collapse B classes. Remove
  29.                                     somInit methods. Don't call IsInitialized
  30.                                     or SubclassResponsibility
  31.         <15>     7/26/95    DM        #1270320: Memory leak fixes: dispose descs
  32.                                     in NotifyUndoOrRedoOrDispose
  33.         <14>     6/16/95    TJ        Uncommented the pragma export_lib on.
  34.         <13>     6/15/95    NP        1237542: Fix CORBA memory stuff, 1249152:
  35.                                     Undo not respecting marks
  36.         <12>     5/26/95    RR        #1251403: Multithreading naming support
  37.         <11>     5/21/95    NP        1249290: Fix crash if libraries are
  38.                                     preloaded.
  39.         <10>      5/3/95    NP        1211084: Remove 5$
  40.          <9>     4/28/95    NP        1223103: Logic error in Undo. 1243568,
  41.                                     1209554: use of ODGetSystemHeap.
  42.          <8>     4/26/95    NP        1243568: Don't use ODSystemHeap.
  43.          <7>     4/14/95    NP        1238258: Don't use OrderedCollection, use a
  44.                                     collection class that has no virtual
  45.                                     methods and that uses no classes with
  46.                                     virtual methods.
  47.          <6>     4/14/95    NP        1217965: Destroy all system objects when
  48.                                     last doc is closed.
  49.          <5>     1/26/95    eeh        1213354: ODActionData now an ODByteArray.
  50.          <4>     1/25/95    jpa        New ODIText format [1212619]
  51.          <3>    12/25/94    TÇ        1191189 Eliminate duplicate Def.h, Def.xh
  52.                                     files
  53.          <2>     9/29/94    RA        1189812: Mods for 68K build.
  54.          <1>     7/27/94    NP        first checked in
  55.  
  56.     To Do:
  57.         Remove destructors where not needed.
  58.         
  59. */
  60.  
  61.  
  62. #ifndef _PART_
  63. #include "Part.xh"
  64. #endif
  65.  
  66. //#ifndef _ORDCOLL_
  67. //#include "OrdColl.h"
  68. //#endif
  69.  
  70. #ifndef SOM_Module_OpenDoc_StdDefs_defined
  71. #include "StdDefs.xh"
  72. #endif
  73.  
  74. #ifndef _SEUTILS_
  75. #include "SEUtils.h"
  76. #endif
  77.  
  78. #ifndef _ODUTILS_
  79. #include "ODUtils.h"
  80. #endif
  81.  
  82. #ifndef _ITEXT_
  83. #include "IText.h"
  84. #endif
  85.  
  86. #define ODUndo_Class_Source
  87. #define VARIABLE_MACROS
  88. #include <Undo.xih>
  89.  
  90. #ifndef _EXCEPT_
  91. #include <Except.h>
  92. #endif
  93.  
  94. #ifndef _BARRAY_
  95. #include <BArray.h>
  96. #endif
  97.  
  98. //#ifndef _ODNEW_
  99. //#include <ODNew.h>
  100. //#endif
  101.  
  102. #ifndef _ODDEBUG_
  103. #include "ODDebug.h"
  104. #endif
  105.  
  106. //#ifndef _ODTYPES_
  107. //#include "ODTypes.h"
  108. //#endif
  109.  
  110. //#ifndef _PLFMDEF_
  111. //#include "PlfmDef.h"
  112. //#endif
  113.  
  114. //#ifndef _LIST_
  115. //#include "List.h"
  116. //#endif
  117.  
  118. #ifndef _ODMEMORY_
  119. #include "ODMemory.h"
  120. #endif
  121.  
  122. #ifndef __ERRORS__
  123. #include <Errors.h>
  124. #endif
  125.  
  126. #ifndef _ODDEBUG_
  127. #include "ODDebug.h"
  128. #endif
  129.  
  130. #ifndef _TEMPOBJ_
  131. #include <TempObj.h>
  132. #endif
  133.  
  134. #pragma segment ODUndo
  135.  
  136. /*
  137. IMPLEMENTATION NOTES
  138.  
  139. System Heap allocations
  140.  
  141. Almost all memory allocations occur in the system heap.
  142.  
  143. I'm trying to use as little system heap memory as possible because putting
  144. pointers into the system heap could be a bad idea (mem fragmentation).
  145.  
  146. UNDO AND REDO STACKS
  147.  
  148. The stacks are implemented with the UndoOrderedCollection class. The first item
  149. in the collection represents the top of the stack.
  150.  
  151. MARKING
  152.  
  153. When asked to mark a stack that is empty, nothing is done. The code that removes
  154. actions from a stack up to the last mark simply stops when it comes to the end
  155. of a stack.
  156.  
  157. ADDCLIENT, ETC.
  158.  
  159. We need to use these functions to ensure the SystemUndo is freed when
  160. the last OD document is closed. The memory associated with it will have gone
  161. away.
  162. */
  163.  
  164. //==============================================================================
  165. // Special new operator for the system heap that use NewPtrSys and
  166. //    DisposePtr.
  167. //==============================================================================
  168.  
  169. enum ODUndoMemoryAllocation
  170. {
  171.     kODSystemHeap
  172. };
  173.  
  174. void* operator new(size_t size, ODUndoMemoryAllocation allocation);
  175.  
  176. void* operator new(size_t size, ODUndoMemoryAllocation allocation)
  177. {
  178.     void*    retVal;
  179.  
  180.     if (allocation == kODSystemHeap)
  181.         retVal = NewPtrSys(size);
  182.     else
  183.         THROW(kODErrNotImplemented);
  184.     
  185.     return retVal;
  186. }
  187.  
  188. //==============================================================================
  189. // Temporarily include new UndoOrderedCollection class that I can allocate in the
  190. //    system heap. (May be longer than temporary.)
  191. //==============================================================================
  192.  
  193.  
  194.  
  195. /////////////// BEGIN TEMP HACK
  196.  
  197.  
  198.  
  199. //==============================================================================
  200. // UndoLink
  201. //==============================================================================
  202.  
  203. class  UndoLink {
  204.     public:
  205. //        void* operator new(size_t size) {return NewPtrSys(size);}
  206.         void operator delete(void* ptr) {DisposePtr((Ptr)ptr);}
  207.         UndoLink();
  208.         
  209.         UndoLink(UndoLink* next, UndoLink* previous);
  210.         
  211.         UndoLink( const UndoLink& );
  212.         
  213.         ~UndoLink();
  214.         
  215.         UndoLink* GetNext() const                    {return fNext;}
  216.         
  217.         UndoLink* GetPrevious() const                {return fPrevious;}
  218.     
  219.     // The following operations are provided for efficiency, but DO NOT USE THEM
  220.     // if there are any iterators active on a list. These operations don't bump
  221.     // the list's fSeed and the iterators will not be able to detect that they
  222.     // are out of sync!
  223.         
  224.         void  Remove( );
  225.         
  226.         void  AddBefore( UndoLink *aLink );
  227.         
  228.         void  AddAfter( UndoLink *aLink );
  229.     
  230.   //private-by-convention:
  231.           
  232.         void  SetNext(UndoLink* aLink)                {fNext = aLink;}
  233.         
  234.         void  SetPrevious(UndoLink* aLink)            {fPrevious = aLink;}
  235.  
  236.     private:
  237.     
  238.         UndoLink*        fNext;
  239.         UndoLink*        fPrevious;
  240. };
  241.  
  242.  
  243. //==============================================================================
  244. // UndoLinkedList
  245. //==============================================================================
  246.  
  247.  
  248. class UndoLinkedList {
  249.  
  250.     public:
  251.         void operator delete(void* ptr) {DisposePtr((Ptr)ptr);}
  252.           UndoLinkedList();
  253.           
  254.           ~UndoLinkedList();
  255.           
  256.           void            Remove(UndoLink&);
  257.           
  258.           void            AddFirst(UndoLink* link);
  259.           
  260.           UndoLink*            RemoveFirst();
  261.           
  262.           UndoLink*            First()                                            const;
  263.           
  264. protected:
  265.  
  266.         UndoLink            fSentinel;    // Marks the head & tail
  267.         ODULong            fSeed;        // Used to detect out-of-sync iterators
  268.         
  269.         UndoLink*            GetSentinel( )
  270.                                                 {return &fSentinel;}
  271.         const UndoLink*        GetSentinel( )                                    const
  272.                                                 {return &fSentinel;}
  273.         ODBoolean        IsSentinel( const UndoLink* link )                    const
  274.                                                 {return link==this->GetSentinel();}
  275.         ODBoolean        NotSentinel( const UndoLink* link )                    const
  276.                                                 {return link!=this->GetSentinel();}
  277.  
  278. private:                  
  279.         friend class UndoLinkedListIterator;
  280. };
  281.  
  282.  
  283. //=====================================================================================
  284. // UndoLinkedListIterator
  285. //=====================================================================================
  286.  
  287. class UndoLinkedListIterator {
  288.  
  289.     public:
  290.     
  291.         UndoLinkedListIterator(UndoLinkedList*    list);
  292.         
  293.         ~UndoLinkedListIterator();
  294.         
  295.         UndoLink*            First();
  296.         
  297.         UndoLink*            Next();
  298.  
  299.         ODBoolean         IsNotComplete();
  300.         
  301.     private:
  302.     
  303.         UndoLinkedList*        fList;
  304.         UndoLink*            fCurrent;
  305.         UndoLink*            fNext;        // Used only when deleting while iterating
  306.         UndoLink*             fPrevious;    // Used only when deleting while iterating
  307.         UndoLink*            fSentinel;
  308.         ODULong            fSeed;        // Used to detect out-of-sync iterators
  309.         
  310. };
  311.  
  312. //==============================================================================
  313. // Scalar Types
  314. //==============================================================================
  315.  
  316. typedef void* ElementType;
  317.  
  318. //=====================================================================================
  319. // Class UndoValueLink - Definition
  320. //=====================================================================================
  321.  
  322. class UndoValueLink : public UndoLink {
  323.     
  324. public:
  325.                             UndoValueLink(ElementType value);        
  326.                     ~UndoValueLink();
  327.         ElementType    GetValue()                        { return fValue;}
  328.      void        SetValue(ElementType v)            { fValue = v;}
  329.  
  330. private:
  331.     ElementType         fValue;
  332. };
  333.  
  334. //=====================================================================================
  335. // Class UndoOrderedCollection
  336. //=====================================================================================
  337.  
  338. class UndoOrderedCollection
  339. {
  340.     
  341. public:
  342.     void operator delete(void* ptr) {DisposePtr((Ptr)ptr);}
  343.     UndoOrderedCollection();
  344.     UndoOrderedCollection(ODUndoMemoryAllocation where);
  345.     ~UndoOrderedCollection();
  346.  
  347.      void    AddFirst(ElementType element);
  348.      ElementType    First();
  349.         // Returns kODNULL if there is no first element.
  350.      ElementType    RemoveFirst();
  351.         // Don't call if there are no elements. Crash will result.
  352.      void    Remove(ElementType existing);
  353.      void    RemoveAll();
  354.     
  355.         // Called from the destructor. Removes all elements, deleting the links
  356.         // Does not delete the elements themselves
  357.  
  358. protected:
  359.       UndoValueLink*     CreateNewLink(ElementType value) const;
  360.       ODBoolean    ElementsMatch(ElementType v1,ElementType v2) const;
  361.          // Does a pointer comparison by default 
  362.  
  363. private:
  364.     UndoLinkedList        fImplementation;
  365.     ODUndoMemoryAllocation    fHeap; // if kODNULL, use default heap.
  366.  
  367.     friend class UndoOrderedCollectionIterator;
  368.     friend class ListIterator;
  369. };
  370.  
  371. //=====================================================================================
  372. // Class UndoOrderedCollectionIterator
  373. //=====================================================================================
  374.  
  375. class UndoOrderedCollectionIterator {
  376. public:
  377.     UndoOrderedCollectionIterator(UndoOrderedCollection* collection);
  378.     ~UndoOrderedCollectionIterator();
  379.     ElementType    First();
  380.     ElementType    Next();
  381.     ODBoolean    IsNotComplete();
  382.     
  383. private:
  384.       UndoOrderedCollection*    fCollection;
  385.     UndoLinkedListIterator    fImplementation;
  386. };
  387.  
  388. //==============================================================================
  389. // UndoLink
  390. //==============================================================================
  391.  
  392.  
  393.  
  394. // Many of the simple link methods are inlines; see List.h for implementations.
  395.  
  396.  
  397. //------------------------------------------------------------------------------
  398. // UndoLink::UndoLink
  399. //
  400. // Constructor for UndoLink
  401. //------------------------------------------------------------------------------
  402.  
  403. UndoLink::UndoLink()                            
  404. { 
  405.     fNext = kODNULL; 
  406.     fPrevious = kODNULL;
  407. }
  408.  
  409. //------------------------------------------------------------------------------
  410. // UndoLink::UndoLink
  411. //
  412. // Constructor for UndoLink
  413. //------------------------------------------------------------------------------
  414.  
  415. UndoLink::UndoLink(UndoLink* next, UndoLink* previous)                            
  416. { 
  417.     fNext = next; 
  418.     fPrevious = previous;
  419. }
  420.  
  421. //------------------------------------------------------------------------------
  422. // UndoLink::UndoLink
  423. //
  424. // Copy constructor for UndoLink
  425. //------------------------------------------------------------------------------
  426.  
  427. UndoLink::UndoLink( const UndoLink &link )                            
  428. { 
  429.     fNext = link.fNext; 
  430.     fPrevious = link.fPrevious;
  431. }
  432.  
  433. //------------------------------------------------------------------------------
  434. // UndoLink::UndoLink
  435. //
  436. // Destructor for UndoLink
  437. //------------------------------------------------------------------------------
  438.  
  439. UndoLink::~UndoLink()                                            
  440. {
  441. }
  442.  
  443. //------------------------------------------------------------------------------
  444. // UndoLink::Remove
  445. //
  446. // Remove a link from its list (if any). DO NOT call this directly if there are
  447. // any iterators active on the list; use UndoLinkedList::Remove instead.
  448. //------------------------------------------------------------------------------
  449.  
  450. void    UndoLink::Remove( )
  451. {
  452.     if( fPrevious )
  453.         fPrevious->SetNext(fNext);
  454.     if( fNext )
  455.         fNext->SetPrevious(fPrevious);
  456.     fNext = kODNULL;
  457.     fPrevious = kODNULL;
  458. }
  459.  
  460. //------------------------------------------------------------------------------
  461. // UndoLink::AddBefore
  462. //
  463. // Add a link to a list before another link. It must not already be on any list.
  464. // DO NOT call this directly if there are any iterators active on the list;
  465. // use UndoLinkedList::Remove instead.
  466. //------------------------------------------------------------------------------
  467.  
  468. void    UndoLink::AddBefore( UndoLink *link )
  469. {
  470.     ASSERT(link!=kODNULL,paramErr);
  471.     WASSERT(fNext==kODNULL);
  472.     WASSERT(fPrevious==kODNULL);
  473.     fNext = link;
  474.     fPrevious = link->GetPrevious();
  475.     fPrevious->SetNext(this);
  476.     fNext->SetPrevious(this);
  477. }
  478.  
  479. //------------------------------------------------------------------------------
  480. // UndoLink::AddAfter
  481. //
  482. // Add a link to a list after another link. It must not already be on any list.
  483. // DO NOT call this directly if there are any iterators active on the list;
  484. // use UndoLinkedList::Remove instead.
  485. //------------------------------------------------------------------------------
  486.  
  487. void    UndoLink::AddAfter( UndoLink *link )
  488. {
  489.     ASSERT(link!=kODNULL,paramErr);
  490.     WASSERT(fNext==kODNULL);
  491.     WASSERT(fPrevious==kODNULL);
  492.     fPrevious = link;
  493.     fNext = link->GetNext();
  494.     fPrevious->SetNext(this);
  495.     fNext->SetPrevious(this);
  496. }
  497.  
  498. //======================================================================================
  499. // Class UndoLinkedList
  500. //======================================================================================
  501.  
  502. //------------------------------------------------------------------------------
  503. // UndoLinkedList::UndoLinkedList
  504. //
  505. // Constructor for UndoLinkedList
  506. //------------------------------------------------------------------------------
  507.  
  508. UndoLinkedList::UndoLinkedList()
  509.     :fSentinel(&fSentinel,&fSentinel),
  510.      fSeed(0)
  511. {
  512. }
  513.  
  514. //------------------------------------------------------------------------------
  515. // UndoLinkedList::~UndoLinkedList
  516. //
  517. // Destructor for UndoLinkedList
  518. //------------------------------------------------------------------------------
  519.  
  520. UndoLinkedList::~UndoLinkedList()
  521. {
  522.     // The list does NOT delete all its links!
  523. }
  524.  
  525. //------------------------------------------------------------------------------
  526. // UndoLinkedList::Remove
  527. //
  528. // Description
  529. //------------------------------------------------------------------------------
  530.  
  531. void    UndoLinkedList::Remove(UndoLink& aLink)
  532. {
  533.     fSeed++;
  534.     aLink.Remove();
  535. }
  536.  
  537. //------------------------------------------------------------------------------
  538. // UndoLinkedList::RemoveFirst
  539. //
  540. // Description
  541. //------------------------------------------------------------------------------
  542.  
  543. UndoLink* UndoLinkedList::RemoveFirst()
  544. {
  545.     UndoLink* old = fSentinel.GetNext();
  546.     if (this->NotSentinel(old))
  547.     {
  548.         fSeed++;
  549.         old->Remove();
  550.         return old;
  551.     }
  552.     else
  553.     {
  554.         return kODNULL;
  555.     }
  556. }
  557.  
  558. //------------------------------------------------------------------------------
  559. // UndoLinkedList::AddFirst
  560. //
  561. // Description
  562. //------------------------------------------------------------------------------
  563.  
  564. void    UndoLinkedList::AddFirst(UndoLink* link)
  565. {
  566.     link->AddAfter(this->GetSentinel());
  567.     fSeed++;
  568. }
  569.  
  570. //------------------------------------------------------------------------------
  571. // UndoLinkedList::First
  572. //
  573. // Description
  574. //------------------------------------------------------------------------------
  575.  
  576. UndoLink*    UndoLinkedList::First()  const
  577. {
  578.     return this->NotSentinel(fSentinel.GetNext()) ? fSentinel.GetNext() : (UndoLink*) kODNULL;
  579. }
  580.  
  581. //======================================================================================
  582. // Class UndoLinkedListIterator
  583. //======================================================================================
  584.  
  585. //------------------------------------------------------------------------------
  586. // UndoLinkedListIterator::UndoLinkedListIterator
  587. //
  588. // Constructor for UndoLinkedListIterator
  589. //------------------------------------------------------------------------------
  590.  
  591. UndoLinkedListIterator::UndoLinkedListIterator(UndoLinkedList* list)
  592. {
  593.     fList = list;
  594.     fCurrent = kODNULL;
  595.     fNext = kODNULL;
  596.     fPrevious = kODNULL;
  597.     fSentinel = &list->fSentinel;
  598.     fSeed = fList->fSeed;    
  599. }
  600.  
  601. //------------------------------------------------------------------------------
  602. // UndoLinkedListIterator::~UndoLinkedListIterator
  603. //
  604. // Destructor for UndoLinkedListIterator
  605. //------------------------------------------------------------------------------
  606.  
  607. UndoLinkedListIterator::~UndoLinkedListIterator()
  608. {
  609. }
  610.  
  611. //------------------------------------------------------------------------------
  612. // UndoLinkedListIterator::First
  613. //
  614. // Description
  615. //------------------------------------------------------------------------------
  616.  
  617. UndoLink* UndoLinkedListIterator::First()
  618. {
  619.     if (fList == kODNULL)
  620.         return kODNULL;
  621.         
  622.     if (fSeed != fList->fSeed)
  623.         THROW(kODErrIteratorOutOfSync);
  624.         
  625.     fCurrent = fList->First();
  626.     if (fCurrent == fSentinel)
  627.         fCurrent = kODNULL;
  628.     return fCurrent;
  629. }
  630.  
  631. //------------------------------------------------------------------------------
  632. // UndoLinkedListIterator::Next
  633. //
  634. // Description
  635. //------------------------------------------------------------------------------
  636.  
  637. UndoLink* UndoLinkedListIterator::Next()
  638. {
  639.     if (fList == kODNULL)
  640.         return kODNULL;
  641.  
  642.     if (fSeed != fList->fSeed)
  643.         THROW(kODErrIteratorOutOfSync);
  644.  
  645.     if (fCurrent == kODNULL)
  646.     {
  647.         if ((fNext == kODNULL) && (fPrevious == kODNULL))    // Just starting out
  648.         {
  649.             return this->First();
  650.         }
  651.         else    // Just deleted
  652.         {
  653.             fCurrent = fNext;
  654.             fPrevious = kODNULL;
  655.             fNext = kODNULL;
  656.         }
  657.     }
  658.     else
  659.         fCurrent = fCurrent->GetNext();
  660.     
  661.     if (fCurrent == fSentinel)
  662.         fCurrent = kODNULL;
  663.     return fCurrent;
  664. }
  665.  
  666. //------------------------------------------------------------------------------
  667. // UndoLinkedListIterator::IsNotComplete
  668. //
  669. // Description
  670. //------------------------------------------------------------------------------
  671.  
  672. ODBoolean UndoLinkedListIterator::IsNotComplete()
  673. {
  674.     return (fCurrent != kODNULL);
  675. }
  676.  
  677. //======================================================================================
  678. // Class UndoValueLink - Implementation
  679. //======================================================================================
  680.  
  681. UndoValueLink::UndoValueLink(ElementType value)
  682. {
  683.     fValue = value;
  684. }
  685.  
  686. UndoValueLink::~UndoValueLink()
  687. {
  688. }
  689.  
  690. //======================================================================================
  691. // Class UndoOrderedCollection
  692. //======================================================================================
  693.  
  694. //------------------------------------------------------------------------------
  695. // UndoOrderedCollection::UndoOrderedCollection
  696. //------------------------------------------------------------------------------
  697.  
  698. UndoOrderedCollection::UndoOrderedCollection()
  699. {
  700.     fHeap = kODSystemHeap;
  701. }
  702.  
  703. //------------------------------------------------------------------------------
  704. // UndoOrderedCollection::UndoOrderedCollection
  705. //------------------------------------------------------------------------------
  706.  
  707. UndoOrderedCollection::UndoOrderedCollection(ODUndoMemoryAllocation where)
  708. {
  709.     fHeap = where;
  710. }
  711.  
  712. // UndoOrderedCollection::~UndoOrderedCollection
  713. //------------------------------------------------------------------------------
  714.  
  715. UndoOrderedCollection::~UndoOrderedCollection()
  716. {
  717.     this->RemoveAll();
  718. }
  719.  
  720. //------------------------------------------------------------------------------
  721. // UndoOrderedCollection::AddFirst
  722. //------------------------------------------------------------------------------
  723.  
  724. void UndoOrderedCollection::AddFirst(ElementType element)
  725. {
  726.     UndoValueLink* newLink = this->CreateNewLink(element);
  727.     fImplementation.AddFirst(newLink);
  728. }
  729.  
  730. //------------------------------------------------------------------------------
  731. // UndoOrderedCollection::First
  732. //------------------------------------------------------------------------------
  733.  
  734. ElementType UndoOrderedCollection::First()
  735. {
  736.     UndoValueLink* firstLink = (UndoValueLink*) fImplementation.First();
  737.     return firstLink ? firstLink->GetValue() : (ElementType)kODNULL;
  738. }
  739.  
  740. //------------------------------------------------------------------------------
  741. // UndoOrderedCollection::RemoveFirst
  742. //------------------------------------------------------------------------------
  743.  
  744. ElementType    UndoOrderedCollection::RemoveFirst()
  745. {
  746.     UndoValueLink* aLink = (UndoValueLink*) fImplementation.RemoveFirst();
  747.     ElementType value = aLink ? aLink->GetValue() : kODNULL;
  748.     delete aLink;
  749.     return value;
  750. }
  751.  
  752. //------------------------------------------------------------------------------
  753. // UndoOrderedCollection::Remove
  754. //------------------------------------------------------------------------------
  755.  
  756. void UndoOrderedCollection::Remove(ElementType existing)
  757. {
  758.     UndoLinkedListIterator iter(&fImplementation);
  759.     UndoValueLink* aLink = (UndoValueLink*) iter.First();
  760.     while (aLink != kODNULL)
  761.     {
  762.         ElementType v = ((UndoValueLink*) aLink)->GetValue();
  763.  
  764.         if (this->ElementsMatch(v,existing))
  765.         {
  766.             fImplementation.Remove(*aLink);
  767.             delete aLink;
  768.             aLink = kODNULL;    
  769.         }
  770.         else
  771.             aLink = (UndoValueLink*) iter.Next();
  772.     }    
  773. }
  774.  
  775. //------------------------------------------------------------------------------
  776. // UndoOrderedCollection::RemoveAll
  777. //------------------------------------------------------------------------------
  778.  
  779. void UndoOrderedCollection::RemoveAll()
  780. {
  781.     UndoLink* link = fImplementation.RemoveFirst();
  782.     while (link != kODNULL)
  783.     {
  784.         delete link;
  785.         link = fImplementation.RemoveFirst();
  786.     }
  787. }
  788.  
  789. //------------------------------------------------------------------------------
  790. // UndoOrderedCollection::CreateNewLink
  791. //------------------------------------------------------------------------------
  792.  
  793. UndoValueLink*    UndoOrderedCollection::CreateNewLink(ElementType value) const
  794. {
  795.     return new (fHeap) UndoValueLink(value);
  796. }
  797.  
  798. //------------------------------------------------------------------------------
  799. // UndoOrderedCollection::ElementsMatch
  800. //------------------------------------------------------------------------------
  801.  
  802. ODBoolean    UndoOrderedCollection::ElementsMatch(ElementType v1,ElementType v2) const
  803. {
  804.     return (v1 == v2);
  805. }
  806.  
  807. //======================================================================================
  808. // UndoOrderedCollectionIterator
  809. //======================================================================================
  810.  
  811. //------------------------------------------------------------------------------
  812. // UndoOrderedCollectionIterator::UndoOrderedCollectionIterator
  813. //------------------------------------------------------------------------------
  814.  
  815. UndoOrderedCollectionIterator::UndoOrderedCollectionIterator(UndoOrderedCollection* collection)    
  816.     : fImplementation(collection ? &(collection->fImplementation) : (UndoLinkedList*)kODNULL)
  817. {
  818.     fCollection =  collection;
  819. }
  820.  
  821. //------------------------------------------------------------------------------
  822. // UndoOrderedCollectionIterator::~UndoOrderedCollectionIterator
  823. //------------------------------------------------------------------------------
  824.  
  825. UndoOrderedCollectionIterator::~UndoOrderedCollectionIterator()                        
  826. {
  827. }
  828.  
  829. //------------------------------------------------------------------------------
  830. // UndoOrderedCollectionIterator::First
  831. //------------------------------------------------------------------------------
  832.  
  833. ElementType    UndoOrderedCollectionIterator::First()
  834. {
  835.     UndoValueLink* link = (UndoValueLink*) fImplementation.First();
  836.     
  837.     return link ? link->GetValue() : (ElementType)kODNULL;
  838. }
  839.  
  840. //------------------------------------------------------------------------------
  841. // UndoOrderedCollectionIterator::Next
  842. //------------------------------------------------------------------------------
  843.  
  844. ElementType    UndoOrderedCollectionIterator::Next()
  845. {        
  846.     UndoValueLink* link = (UndoValueLink*) fImplementation.Next();
  847.     
  848.     return link ? link->GetValue() : (ElementType)kODNULL;
  849. }
  850.  
  851. //------------------------------------------------------------------------------
  852. // UndoOrderedCollectionIterator::IsNotComplete
  853. //------------------------------------------------------------------------------
  854.  
  855. ODBoolean    UndoOrderedCollectionIterator::IsNotComplete()
  856. {
  857.     return fImplementation.IsNotComplete();
  858. }
  859.  
  860.  
  861.  
  862. /////////////// END TEMP HACK
  863.  
  864.  
  865.  
  866. //==============================================================================
  867. // Constants
  868. //==============================================================================
  869.  
  870. const OSType kUndoNotifyID = 'undo';
  871. const OSType kRedoNotifyID = 'redo';
  872. const OSType kDisposeActionNotifyID = 'del ';
  873.  
  874. const AEKeyword kDataPtrKeyword = 'data';
  875. const AEKeyword kPartPtrKeyword = 'part';
  876. const AEKeyword kDoneStateKeyword = 'done';
  877.  
  878. // A number of functions can share code. They pass along this enum to know
  879. //    which course of action to take.
  880. enum ODUndoRedoType
  881. {
  882.     kUndo,
  883.     kRedo,
  884.     kDispose
  885. };
  886.  
  887. //==============================================================================
  888. // Classes used in this file
  889. //==============================================================================
  890.  
  891. class UndoAction;
  892. class SystemUndo;
  893.  
  894. //==============================================================================
  895. // Function Prototypes
  896. //==============================================================================
  897.  
  898. static OSErr NotifyUndoOrRedoOrDispose(UndoAction* action,
  899.                                                 ODUndoRedoType which);
  900. static OSErr NotifyUndo(UndoAction* action);
  901. static OSErr NotifyRedo(UndoAction* action);
  902. static OSErr NotifyDispose(UndoAction* action);
  903. static SystemUndo *GetSystemUndo();
  904. static ODBoolean SetSystemUndo(SystemUndo *systemUndo);
  905.  
  906. //==============================================================================
  907. // Functions
  908. //==============================================================================
  909.  
  910. // • Using ASLM we registered the system undo object with ASLM using the
  911. // arbitration mechanism provided by ASLM. To eliminate our dependency on ASLM
  912. // we are storing the system undo object in a global which is accessed by the
  913. // following two functions. This is NOT a thread safe method for accessing the
  914. // system undo!
  915.  
  916. //------------------------------------------------------------------------------
  917. // GetSystemUndo
  918. //------------------------------------------------------------------------------
  919.  
  920. #pragma lib_export on
  921. extern SystemUndo* gSystemUndo;        
  922. #pragma lib_export off
  923.  
  924. static SystemUndo *GetSystemUndo()
  925. {
  926.     return gSystemUndo;
  927. }
  928.  
  929. //------------------------------------------------------------------------------
  930. // SetSystemUndo
  931. //------------------------------------------------------------------------------
  932.  
  933. static ODBoolean SetSystemUndo(SystemUndo *systemUndo)
  934. {
  935.     gSystemUndo = systemUndo;
  936.     return kODTrue;
  937. }
  938.  
  939. //#pragma lib_export off
  940.  
  941. //==============================================================================
  942. // Local Classes
  943. //==============================================================================
  944.  
  945. //------------------------------------------------------------------------------
  946.  
  947. class UndoAction
  948. {
  949.   public:
  950.         void operator delete(void* ptr) {DisposePtr((Ptr)ptr);}
  951.     UndoAction(ODPart* whichPart, ODActionData* actionData,
  952.                     ODActionType actionType, ODName* undoActionLabel,
  953.                     ODName* redoActionLabel);
  954.     ~UndoAction();
  955.  
  956.     ODPart*                fPart;
  957.     ProcessSerialNumber    fProcessNum;
  958.     ODActionData*        fActionData;
  959.     ODActionType        fActionType;
  960.     ODName*                fUndoActionLabel;
  961.     ODName*                fRedoActionLabel;
  962.     ODBoolean            fMark;
  963.     ODDoneState            fDoneState;
  964. };
  965.  
  966. //------------------------------------------------------------------------------
  967. // UndoAction::UndoAction
  968. //
  969. //    This constructor may throw an error, but it's OK because there is nothing
  970. //    to deallocate in the destructor.
  971. //------------------------------------------------------------------------------
  972.  
  973. UndoAction::UndoAction(ODPart* whichPart, 
  974.                                     ODActionData* actionData,
  975.                                     ODActionType actionType,
  976.                                     ODName* undoActionLabel,
  977.                                     ODName* redoActionLabel)
  978. {
  979.     fPart = whichPart;
  980.     THROW_IF_ERROR(GetCurrentProcess(&fProcessNum));
  981.     fActionData = actionData;
  982.     fActionType = actionType;
  983.     fUndoActionLabel = undoActionLabel;
  984.     fRedoActionLabel = redoActionLabel;
  985.     fMark = kODFalse;
  986.     fDoneState = kODDone;
  987. }
  988.  
  989. //------------------------------------------------------------------------------
  990. // UndoAction::~UndoAction
  991. //
  992. //    Notify owning part owning fActionData to dipose of any associated memory.
  993. //------------------------------------------------------------------------------
  994.  
  995. UndoAction::~UndoAction()
  996. {
  997.     NotifyDispose(this);
  998.  
  999.     DisposeIText(fUndoActionLabel);
  1000.     DisposeIText(fRedoActionLabel);
  1001.     DisposeByteArray(fActionData);
  1002. }
  1003.  
  1004. //------------------------------------------------------------------------------
  1005.  
  1006. class SystemUndo
  1007. {
  1008.   public:
  1009.         void operator delete(void* ptr) {DisposePtr((Ptr)ptr);}
  1010.     SystemUndo();
  1011.     ~SystemUndo();
  1012.     void    Initialize();
  1013.  
  1014.     ODSize        Purge(ODSize size);
  1015.     ODBoolean    CheckActionOK(UndoAction* action);
  1016.     void        AddActionToHistory(ODPart* whichPart, 
  1017.                                     ODActionData* actionData,
  1018.                                     ODActionType actionType,
  1019.                                     ODName* undoActionLabel,
  1020.                                     ODName* redoActionLabel);
  1021.     void    Undo();
  1022.     void    Redo();
  1023.     void    MarkActionHistory();
  1024.     void    ClearActionHistory(ODRespectMarksChoices respectMarks);
  1025.     void    ClearRedoHistory();
  1026.     ODBoolean    PeekUndoHistory(ODPart** part,
  1027.                                 ODActionData* actionData,
  1028.                                 ODActionType* actionType,
  1029.                                 ODName* actionLabel);
  1030.     ODBoolean    PeekRedoHistory(ODPart** part,
  1031.                                 ODActionData* actionData,
  1032.                                 ODActionType* actionType,
  1033.                                 ODName* actionLabel);
  1034.     void        RemoveEntriesForThisProcess();
  1035.     void        AddClient(ODUndo* docUndoObject);
  1036.     void        RemoveClient(ODUndo* docUndoObject);
  1037.     ODULong        GetNumClients();
  1038.     void        AbortCurrentTransaction();
  1039.   private:
  1040.     void        TransactionUndo(UndoAction* firstAction);
  1041.     void        TransactionRedo(UndoAction* firstAction);
  1042.     void        MarkActionOrSelf(UndoAction* action, ODBoolean* mark);
  1043.     void        ClearActionsToMark(UndoOrderedCollection* stack);
  1044.     void        ClearStack(UndoOrderedCollection* stack);
  1045.     ODBoolean    PeekHistory(ODPart** part,
  1046.                                 ODActionData* actionData,
  1047.                                 ODActionType* actionType,
  1048.                                 ODName* actionLabel,
  1049.                                 ODUndoRedoType which);
  1050.     void        MoveUndoToRedo();
  1051.     void        MoveRedoToUndo();
  1052.  
  1053.     UndoOrderedCollection*        fUndoStack;
  1054.     UndoOrderedCollection*        fRedoStack;
  1055.     ODULong                        fInTransaction;
  1056.     ODBoolean                fCurrentlyUndoingOrRedoing;
  1057.     ODULong                fNumUsers;
  1058. };
  1059.  
  1060. //------------------------------------------------------------------------------
  1061. // SystemUndo::SystemUndo
  1062. //------------------------------------------------------------------------------
  1063.  
  1064. SystemUndo::SystemUndo()
  1065. {
  1066.     fUndoStack = kODNULL;
  1067.     fRedoStack = kODNULL;
  1068.     fInTransaction = 0;
  1069.     fCurrentlyUndoingOrRedoing = kODFalse;
  1070.     fNumUsers = 0;
  1071. }
  1072.  
  1073. //------------------------------------------------------------------------------
  1074. // SystemUndo::Initialize                
  1075. //------------------------------------------------------------------------------
  1076.  
  1077. void SystemUndo::Initialize ()
  1078. {
  1079.     ODUndoMemoryAllocation    heap = kODSystemHeap;
  1080.  
  1081.     fUndoStack = new (heap) UndoOrderedCollection(heap);
  1082.     fRedoStack = new (heap) UndoOrderedCollection(heap);
  1083.  
  1084. }
  1085.  
  1086. //------------------------------------------------------------------------------
  1087. // SystemUndo::~SystemUndo
  1088. //------------------------------------------------------------------------------
  1089.  
  1090. SystemUndo::~SystemUndo()
  1091. {
  1092. //    WASSERTM(0, "System Undo object being destroyed!");
  1093.     delete fUndoStack;
  1094.     delete fRedoStack;
  1095. }
  1096.  
  1097. //------------------------------------------------------------------------------
  1098. // SystemUndo::Purge
  1099. //------------------------------------------------------------------------------
  1100.         
  1101. ODSize    SystemUndo::Purge(ODSize size)
  1102. {
  1103.     ODUnused(size);
  1104.     return 0;
  1105. }
  1106.  
  1107. //------------------------------------------------------------------------------
  1108. // SystemUndo::CheckActionOK
  1109. //------------------------------------------------------------------------------
  1110.         
  1111. ODBoolean SystemUndo::CheckActionOK(UndoAction* action)
  1112. {
  1113.     if (action && !(action->fMark))
  1114.         return kODTrue;
  1115.     return kODFalse;
  1116. }
  1117.  
  1118. //------------------------------------------------------------------------------
  1119. // SystemUndo::AddClient
  1120. //------------------------------------------------------------------------------
  1121.         
  1122. void SystemUndo::AddClient(ODUndo* docUndoObject)
  1123. {
  1124.     ODUnused(docUndoObject);
  1125.     ++fNumUsers;
  1126. }
  1127.  
  1128. //------------------------------------------------------------------------------
  1129. // SystemUndo::RemoveClient
  1130. //------------------------------------------------------------------------------
  1131.         
  1132. void SystemUndo::RemoveClient(ODUndo* docUndoObject)
  1133. {
  1134.     ODUnused(docUndoObject);
  1135.     --fNumUsers;
  1136. }
  1137.  
  1138. //------------------------------------------------------------------------------
  1139. // SystemUndo::GetNumClients
  1140. //------------------------------------------------------------------------------
  1141.         
  1142. ODULong SystemUndo::GetNumClients()
  1143. {
  1144.     return fNumUsers;
  1145. }
  1146.  
  1147. //------------------------------------------------------------------------------
  1148. // SystemUndo::AddActionToHistory
  1149. //------------------------------------------------------------------------------
  1150.  
  1151. void SystemUndo::AddActionToHistory(ODPart* whichPart, 
  1152.                                     ODActionData* actionData,
  1153.                                     ODActionType actionType,
  1154.                                     ODName* undoActionLabel,
  1155.                                     ODName* redoActionLabel)
  1156. {
  1157.     if (fCurrentlyUndoingOrRedoing)
  1158.         THROW(kODErrCannotAddAction);
  1159.  
  1160. //    if (fInTransaction && actionType == kODBeginAction)
  1161. //        THROW(kODErrCannotAddAction);
  1162.  
  1163.     if (actionType == kODBeginAction)
  1164.         ++fInTransaction;
  1165.     if (actionType == kODEndAction)
  1166.         --fInTransaction;
  1167.  
  1168.     // NOT DOING THESE ALLOCATIONS IN THE SYSTEM HEAP!
  1169.     ODIText* undoName = CopyIText(undoActionLabel);
  1170.     ODIText* redoName = CopyIText(redoActionLabel);
  1171.  
  1172.     ODActionData* copiedData = (ODActionData*)ODNewPtr(sizeof(ODActionData));
  1173.     copiedData->_buffer = (octet*)ODNewPtr(actionData->_length);
  1174.     ODBlockMove(actionData->_buffer, copiedData->_buffer, actionData->_length);
  1175.     copiedData->_length = actionData->_length;
  1176.     copiedData->_maximum = actionData->_length;
  1177.  
  1178.     UndoAction* action =
  1179.                     new (kODSystemHeap) UndoAction(whichPart, copiedData,
  1180.                                                     actionType, undoName,
  1181.                                                     redoName);
  1182.     fUndoStack->AddFirst(action);
  1183.     this->ClearStack(fRedoStack);
  1184. }
  1185.  
  1186. //------------------------------------------------------------------------------
  1187. // SystemUndo::MoveUndoToRedo
  1188. //
  1189. //    Utility to move item from top of one stack to the top of another.
  1190. //------------------------------------------------------------------------------
  1191.  
  1192. void SystemUndo::MoveUndoToRedo()
  1193. {
  1194.     ElementType item = fUndoStack->RemoveFirst();
  1195.     ((UndoAction*)item)->fDoneState = kODUndone;
  1196.     fRedoStack->AddFirst(item);
  1197. }
  1198.  
  1199. //------------------------------------------------------------------------------
  1200. // SystemUndo::MoveRedoToUndo
  1201. //
  1202. //    Utility to move item from top of one stack to the top of another.
  1203. //------------------------------------------------------------------------------
  1204.  
  1205. void SystemUndo::MoveRedoToUndo()
  1206. {
  1207.     ElementType item = fRedoStack->RemoveFirst();
  1208.     ((UndoAction*)item)->fDoneState = kODRedone;
  1209.     fUndoStack->AddFirst(item);
  1210. }
  1211.  
  1212. //------------------------------------------------------------------------------
  1213. // SystemUndo::Undo
  1214. //
  1215. //    If there's an error while undoing anything, just clear the stacks and get
  1216. //    out.
  1217. //------------------------------------------------------------------------------
  1218.  
  1219. void SystemUndo::Undo()
  1220. {
  1221.     UndoAction* action = (UndoAction*)fUndoStack->First();
  1222.     if (!this->CheckActionOK(action))
  1223.         THROW(kODErrEmptyStack);
  1224.  
  1225.     fCurrentlyUndoingOrRedoing = kODTrue;
  1226.  
  1227.     TRY
  1228.         if (action->fActionType == kODEndAction) // End is at top for an Undo
  1229.             this->TransactionUndo(action);
  1230.         else
  1231.         {
  1232.             THROW_IF_ERROR(NotifyUndo(action));
  1233.             this->MoveUndoToRedo();
  1234.         }
  1235.     CATCH_ALL
  1236.         this->ClearActionHistory(kODDontRespectMarks);
  1237.         fCurrentlyUndoingOrRedoing = kODFalse;
  1238.         RERAISE;
  1239.     ENDTRY
  1240.     fCurrentlyUndoingOrRedoing = kODFalse;
  1241. }
  1242.  
  1243. //------------------------------------------------------------------------------
  1244. // SystemUndo::TransactionUndo
  1245. //------------------------------------------------------------------------------
  1246.  
  1247. void SystemUndo::TransactionUndo(UndoAction* firstAction)
  1248. {
  1249.     UndoAction*    action;
  1250.     ODULong        nestedTransactionCounter = 1;
  1251.  
  1252.     THROW_IF_ERROR(NotifyUndo(firstAction));
  1253.     this->MoveUndoToRedo();
  1254.  
  1255.     do
  1256.     {
  1257.         action = (UndoAction*)fUndoStack->First();
  1258.         if (action == (UndoAction*)kODNULL)
  1259.             THROW(kODErrNoBeginAction);
  1260.         THROW_IF_ERROR(NotifyUndo(action));
  1261.         this->MoveUndoToRedo();
  1262.         if (action->fActionType == kODBeginAction)
  1263.             --nestedTransactionCounter;
  1264.         else if (action->fActionType == kODEndAction)
  1265.             ++nestedTransactionCounter;
  1266.     }
  1267.     while (nestedTransactionCounter);
  1268. }
  1269.  
  1270. //------------------------------------------------------------------------------
  1271. // SystemUndo::Redo
  1272. //------------------------------------------------------------------------------
  1273.  
  1274. void SystemUndo::Redo()
  1275. {
  1276.     UndoAction* action = (UndoAction*)fRedoStack->First();
  1277.     if (!this->CheckActionOK(action))
  1278.         THROW(kODErrEmptyStack);
  1279.  
  1280.     fCurrentlyUndoingOrRedoing = kODTrue;
  1281.  
  1282.     TRY
  1283.         if (action->fActionType == kODBeginAction)//Start is at top for an Redo
  1284.             this->TransactionRedo(action);
  1285.         else
  1286.         {
  1287.             THROW_IF_ERROR(NotifyRedo(action));
  1288.             this->MoveRedoToUndo();
  1289.         }
  1290.     CATCH_ALL
  1291.         this->ClearActionHistory(kODDontRespectMarks);
  1292.         fCurrentlyUndoingOrRedoing = kODFalse;
  1293.         RERAISE;
  1294.     ENDTRY
  1295.     fCurrentlyUndoingOrRedoing = kODFalse;
  1296. }
  1297.  
  1298. //------------------------------------------------------------------------------
  1299. // SystemUndo::TransactionRedo
  1300. //------------------------------------------------------------------------------
  1301.  
  1302. void SystemUndo::TransactionRedo(UndoAction* firstAction)
  1303. {
  1304.     UndoAction*    action;
  1305.     ODULong        nestedTransactionCounter = 1;
  1306.  
  1307.     THROW_IF_ERROR(NotifyRedo(firstAction));
  1308.     this->MoveRedoToUndo();
  1309.  
  1310.     do
  1311.     {
  1312.         action = (UndoAction*)fRedoStack->First();
  1313. //        if (action == (UndoAction*)kODNULL)
  1314. //            THROW(kODErrNoBeginAction);
  1315.         THROW_IF_ERROR(NotifyRedo(action));
  1316.         this->MoveRedoToUndo();
  1317.         if (action->fActionType == kODBeginAction)
  1318.             ++nestedTransactionCounter;
  1319.         else if (action->fActionType == kODEndAction)
  1320.             --nestedTransactionCounter;
  1321.     }
  1322.     while (nestedTransactionCounter);
  1323. }
  1324.  
  1325. //------------------------------------------------------------------------------
  1326. // SystemUndo::MarkActionHistory
  1327. //------------------------------------------------------------------------------
  1328.  
  1329. void SystemUndo::MarkActionHistory()
  1330. {
  1331.     UndoAction*    action;
  1332.  
  1333.     action = (UndoAction*)fUndoStack->First();
  1334.     if (action)
  1335.         action->fMark = kODTrue;
  1336.     action = (UndoAction*)fRedoStack->First();
  1337.     if (action)
  1338.         action->fMark = kODTrue;
  1339. }
  1340.  
  1341. //------------------------------------------------------------------------------
  1342. // SystemUndo::ClearStack
  1343. //------------------------------------------------------------------------------
  1344.  
  1345. void SystemUndo::ClearStack(UndoOrderedCollection* stack)
  1346. {
  1347.     UndoOrderedCollectionIterator    iter(stack);
  1348.     UndoAction*            action;
  1349.  
  1350.     for (action = (UndoAction*)iter.First();
  1351.             iter.IsNotComplete();
  1352.             action = (UndoAction*)iter.Next())
  1353.     {
  1354.         delete action;
  1355.     }
  1356.     
  1357.     stack->RemoveAll();
  1358. }
  1359.  
  1360. //------------------------------------------------------------------------------
  1361. // SystemUndo::ClearActionsToMark
  1362. //
  1363. //    To make more efficient, should just start removing items from the front of
  1364. //    the list til I hit the mark.
  1365. //------------------------------------------------------------------------------
  1366.  
  1367. void SystemUndo::ClearActionsToMark(UndoOrderedCollection* stack)
  1368. {
  1369.     UndoOrderedCollectionIterator    collectionIter(stack);
  1370.     UndoAction*                    action;
  1371.     UndoOrderedCollection            elementsToDelete;
  1372.  
  1373.     // ADD ELEMENTS TO REMOVE TO A LIST
  1374.     for (action = (UndoAction*)collectionIter.First();
  1375.             collectionIter.IsNotComplete();
  1376.             action = (UndoAction*)collectionIter.Next())
  1377.     {
  1378.         if (action->fMark != kODFalse)
  1379.         {
  1380.             action->fMark = kODFalse;
  1381.             break;
  1382.         }
  1383.         else
  1384.             elementsToDelete.AddFirst(action);
  1385.     }
  1386.  
  1387.     // REMOVE ELEMENTS
  1388.     UndoOrderedCollectionIterator    deleteIter(&elementsToDelete);
  1389.     for (action = (UndoAction*)deleteIter.First();
  1390.             deleteIter.IsNotComplete();
  1391.             action = (UndoAction*)deleteIter.Next())
  1392.     {
  1393.         stack->Remove(action);
  1394.         delete action;
  1395.     }
  1396. }
  1397.  
  1398. //------------------------------------------------------------------------------
  1399. // SystemUndo::ClearActionHistory
  1400. //------------------------------------------------------------------------------
  1401.  
  1402. void SystemUndo::ClearActionHistory(ODRespectMarksChoices respectMarks)
  1403. {
  1404.     if (respectMarks == kODRespectMarks)
  1405.     {
  1406.         this->ClearActionsToMark(fUndoStack);
  1407.         this->ClearActionsToMark(fRedoStack);
  1408.     }
  1409.     else
  1410.     {
  1411.         this->ClearStack(fUndoStack);
  1412.         this->ClearStack(fRedoStack);
  1413.     }
  1414. }
  1415.  
  1416. //------------------------------------------------------------------------------
  1417. // SystemUndo::ClearRedoHistory
  1418. //------------------------------------------------------------------------------
  1419.  
  1420. void SystemUndo::ClearRedoHistory()
  1421. {
  1422.     this->ClearActionsToMark(fRedoStack);
  1423. }
  1424.  
  1425. //------------------------------------------------------------------------------
  1426. // SystemUndo::AbortCurrentTransaction
  1427. //------------------------------------------------------------------------------
  1428.  
  1429. void SystemUndo::AbortCurrentTransaction()
  1430. {
  1431.     ODULong            nestingLevel = 0;
  1432.     ODActionType    actionType;
  1433.  
  1434.     if (fCurrentlyUndoingOrRedoing)
  1435.         return;
  1436.     if (!fInTransaction)
  1437.         return;
  1438.     
  1439.     UndoAction* action = (UndoAction*)fUndoStack->First();
  1440.  
  1441.     do
  1442.     {
  1443.         if (action->fActionType == kODEndAction)
  1444.             ++nestingLevel;
  1445.         fUndoStack->RemoveFirst();
  1446.         actionType = action->fActionType;
  1447.         delete action;
  1448.         if (actionType == kODBeginAction && nestingLevel == 0)
  1449.             break;
  1450.         action = (UndoAction*)fUndoStack->First();//should never be NULL, right?
  1451.     }
  1452.     while (kODTrue);
  1453. }
  1454.  
  1455. //------------------------------------------------------------------------------
  1456. // SystemUndo::PeekUndoHistory
  1457. //------------------------------------------------------------------------------
  1458.  
  1459. ODBoolean SystemUndo::PeekUndoHistory(ODPart** part,
  1460.                                 ODActionData* actionData,
  1461.                                 ODActionType* actionType,
  1462.                                 ODName* actionLabel)
  1463. {
  1464.     return PeekHistory(part, actionData, actionType, actionLabel, kUndo);
  1465. }
  1466.  
  1467. //------------------------------------------------------------------------------
  1468. // SystemUndo::PeekRedoHistory
  1469. //------------------------------------------------------------------------------
  1470.  
  1471. ODBoolean SystemUndo::PeekRedoHistory(ODPart** part,
  1472.                                 ODActionData* actionData,
  1473.                                 ODActionType* actionType,
  1474.                                 ODName* actionLabel)
  1475. {
  1476.     return PeekHistory(part, actionData, actionType, actionLabel, kRedo);
  1477. }
  1478.  
  1479. //------------------------------------------------------------------------------
  1480. // SystemUndo::PeekHistory
  1481. //------------------------------------------------------------------------------
  1482.  
  1483. ODBoolean SystemUndo::PeekHistory(ODPart** part,
  1484.                                 ODActionData* actionData,
  1485.                                 ODActionType* actionType,
  1486.                                 ODName* actionLabel,
  1487.                                 ODUndoRedoType which)
  1488. {
  1489.     UndoOrderedCollection*    stack;
  1490.     ODIText*            iText;
  1491.  
  1492.     if (which == kUndo)
  1493.         stack = fUndoStack;
  1494.     else if (which == kRedo)
  1495.         stack = fRedoStack;
  1496.  
  1497.     UndoAction*    action = (UndoAction*)stack->First();
  1498.  
  1499.     if (!this->CheckActionOK(action))
  1500.         return kODFalse;
  1501.     else
  1502.     {
  1503.         if (action->fMark != kODFalse)
  1504.             return kODFalse;
  1505.         else
  1506.         {
  1507.             *part = action->fPart;
  1508.             *actionType = action->fActionType;
  1509.  
  1510.             *actionData = CopyByteArrayStruct(action->fActionData);
  1511.  
  1512.             if (which == kUndo)
  1513.                 iText = action->fUndoActionLabel;
  1514.             else if (which == kRedo)
  1515.                 iText = action->fRedoActionLabel;
  1516.  
  1517.             *actionLabel = CopyITextStruct(iText);
  1518.  
  1519.             return kODTrue;
  1520.         }
  1521.     }
  1522. }
  1523.  
  1524. //------------------------------------------------------------------------------
  1525. // NotifyUndoOrRedoOrDispose
  1526. //
  1527. //    Notify part to Undo or Redo or Dispose its data.
  1528. //    Could fine-tune to only pack parameters needed according to "which"
  1529. //    parameter
  1530. //------------------------------------------------------------------------------
  1531.  
  1532. static OSErr NotifyUndoOrRedoOrDispose(UndoAction* action,
  1533.                                                 ODUndoRedoType which)
  1534. {
  1535.     AEAddressDesc        address;
  1536.     AppleEvent            message;
  1537.     AppleEvent            reply;
  1538.     OSErr                error = noErr;
  1539.     ProcessSerialNumber    psn;
  1540.     Boolean                isSameProcess;
  1541.     DescType            eventID;
  1542. //    ProcessInfoRec        processRec;
  1543.  
  1544.     TRY
  1545. #if 0
  1546.         // MAKE SURE PROCESS IS STILL VALID. USE SIDE EFFECT OF ERROR RETURN
  1547.         //    FROM GetProcessInformation.
  1548.         processRec.processInfoLength = sizeof(ProcessInfoRec);
  1549.         processRec.processName = kODNULL;
  1550.         processRec.processAppSpec = kODNULL;
  1551.         THROW_IF_ERROR(GetProcessInformation(&action->fProcessNum, &processRec));
  1552. #endif /* 0 */
  1553.         // SOME CODE TO HANDLE THE SEND TO SELF CASE WELL. IF WE HAVE A STANDARD
  1554.         //    IDLE PROC TO USE, WE PROBABLY DON'T NEED THIS. (NP-WHAT DID I MEAN
  1555.         //    HERE?)
  1556.         THROW_IF_ERROR(GetCurrentProcess(&psn));
  1557.         THROW_IF_ERROR(SameProcess(&action->fProcessNum, &psn,
  1558.                                     &isSameProcess));
  1559.         if (isSameProcess)
  1560.         {
  1561.             psn.lowLongOfPSN = kCurrentProcess;
  1562.             psn.highLongOfPSN = 0;
  1563.         }
  1564.         else
  1565.             psn = action->fProcessNum;
  1566. #if 0
  1567.         {
  1568.             // MAKE SURE PROCESS IS STILL ALIVE.
  1569.             ODBoolean    processStillExists = kODFalse;
  1570.             
  1571.             while (kODTrue)
  1572.             {
  1573.                 if (GetNextProcess(&psn) != noErr)
  1574.                     break;
  1575.                 THROW_IF_ERROR(SameProcess(&action->fProcessNum, &psn,
  1576.                                             &isSameProcess));
  1577.                 if (isSameProcess)
  1578.                 {
  1579.                     processStillExists = kODTrue;
  1580.                     break;
  1581.                 }
  1582.             }
  1583.             
  1584.             if (!processStillExists)
  1585.                 THROW(procNotFound);
  1586.         }
  1587. #endif /* 0 */
  1588.         THROW_IF_ERROR(AECreateDesc(typeProcessSerialNumber,
  1589.                                     (Ptr)&psn, sizeof(psn), &address));
  1590.  
  1591.         if (which == kUndo)
  1592.             eventID = kUndoNotifyID;
  1593.         else if (which == kRedo)
  1594.             eventID = kRedoNotifyID;
  1595.         else if (which == kDispose)
  1596.             eventID = kDisposeActionNotifyID;
  1597.  
  1598.         THROW_IF_ERROR(AECreateAppleEvent(kODShellSignature, eventID,
  1599.                         &address, kAutoGenerateReturnID, kAnyTransactionID,
  1600.                         &message));
  1601.         TempAEDesc tempMessage(&message); // DMc make sure it is disposed
  1602.         
  1603.         THROW_IF_ERROR(AEPutParamPtr(&message, kDataPtrKeyword, typeChar,
  1604.                                     action->fActionData->_buffer,
  1605.                                     action->fActionData->_length));
  1606.         
  1607.         THROW_IF_ERROR(AEPutParamPtr(&message, kPartPtrKeyword, typeInteger,
  1608.                                     (Ptr)&action->fPart,
  1609.                                     sizeof(action->fPart)));
  1610.         
  1611.         THROW_IF_ERROR(AEPutParamPtr(&message, kDoneStateKeyword, typeInteger,
  1612.                                     (Ptr)&action->fDoneState,
  1613.                                     sizeof(action->fDoneState)));
  1614.         
  1615.         THROW_IF_ERROR(AESend(&message, &reply,
  1616.                             kAEWaitReply + kAECanInteract + kAECanSwitchLayer
  1617.                             + kAEDontRecord,
  1618.                             kAENormalPriority,
  1619.                             // NP: TEMP FIX: CHANGE TIMEOUT TO 5 SECONDS IF
  1620.                             //    SENDING A DISPOSE. *MAY* CAUSE MEMORY LEAKS,
  1621.                             //    OR, IN THE WORSE CASE, THAT SOME NOTIFICATIONS
  1622.                             //    WILL BE SENT AND OTHERS NOT. THIS MAY CONFUSE
  1623.                             //    A PART.
  1624.                             (which == kDispose ? 5 * 60 : kAEDefaultTimeout),
  1625.                             (AEIdleUPP)kODNULL,
  1626. //                            kAEDefaultTimeout, (AEIdleUPP)kODNULL,
  1627.                             (AEFilterUPP)kODNULL));
  1628.         AEDisposeDesc(&reply); // DMc
  1629.     CATCH_ALL
  1630.         error = ErrorCode();
  1631.     ENDTRY
  1632.     
  1633.     return error;
  1634. }
  1635.  
  1636. //------------------------------------------------------------------------------
  1637. // NotifyUndo
  1638. //
  1639. //    Call ODPart::Undo.
  1640. //------------------------------------------------------------------------------
  1641.  
  1642. static OSErr NotifyUndo(UndoAction* action)
  1643. {
  1644.     return NotifyUndoOrRedoOrDispose(action, kUndo);
  1645. }
  1646.  
  1647. //------------------------------------------------------------------------------
  1648. // NotifyRedo
  1649. //
  1650. //    Call ODPart::Redo.
  1651. //------------------------------------------------------------------------------
  1652.  
  1653. static OSErr NotifyRedo(UndoAction* action)
  1654. {
  1655.     return NotifyUndoOrRedoOrDispose(action, kRedo);
  1656. }
  1657.  
  1658. //------------------------------------------------------------------------------
  1659. // NotifyDispose
  1660. //
  1661. //    Call ODPart::DiposeActionState.
  1662. //------------------------------------------------------------------------------
  1663.  
  1664. static OSErr NotifyDispose(UndoAction* action)
  1665. {
  1666.     return NotifyUndoOrRedoOrDispose(action, kDispose);
  1667. }
  1668.  
  1669. //==============================================================================
  1670. // ODUndo
  1671. //==============================================================================
  1672.  
  1673. //------------------------------------------------------------------------------
  1674. // HandleUndoOrRedoOrDisposeNotify
  1675. //
  1676. //    Could fine-tune to only unpack parameters needed according to "which"
  1677. //    parameter
  1678. //------------------------------------------------------------------------------
  1679.  
  1680. static OSErr HandleUndoOrRedoOrDisposeNotify(AppleEvent* message,
  1681.                                                 AppleEvent* reply,
  1682.                                                 long refCon,
  1683.                                                 ODUndoRedoType which)
  1684. {
  1685.     ODUnused(reply);
  1686.     ODUnused(refCon);
  1687.  
  1688.     OSErr            error = noErr;
  1689.     DescType        gotType;
  1690.     ODActionData*    data;
  1691.     ODPart*            part;
  1692.     ODDoneState        doneState;
  1693.     Size            actualSize;
  1694.     Size            maximumDataSize;
  1695.     Size            maximumPartSize = sizeof(part);
  1696.     Size            maximumDoneStateSize = sizeof(doneState);
  1697.  
  1698.     TRY
  1699.         gotType = typeChar;
  1700.         THROW_IF_ERROR(AESizeOfParam(message, kDataPtrKeyword, &gotType,
  1701.                                         &actualSize));
  1702.         if (gotType != typeChar)
  1703.             THROW(errAECorruptData);
  1704.         maximumDataSize = actualSize;
  1705.         data = CreateEmptyByteArray(actualSize);
  1706.         THROW_IF_ERROR(AEGetParamPtr(message, kDataPtrKeyword, typeChar,
  1707.                                         &gotType, data->_buffer, maximumDataSize,
  1708.                                         &actualSize));
  1709.         if (actualSize != maximumDataSize)
  1710.             THROW(errAECorruptData);
  1711.  
  1712.         THROW_IF_ERROR(AEGetParamPtr(message, kPartPtrKeyword, typeInteger,
  1713.                                     &gotType, (Ptr)&part, maximumPartSize,
  1714.                                     &actualSize));
  1715.         if (gotType != typeInteger || actualSize != maximumPartSize)
  1716.             THROW(errAECorruptData);
  1717.         
  1718.         THROW_IF_ERROR(AEGetParamPtr(message, kDoneStateKeyword, typeInteger,
  1719.                                     &gotType, (Ptr)&doneState,
  1720.                                     maximumDoneStateSize,
  1721.                                     &actualSize));
  1722.         if (gotType != typeInteger || actualSize != maximumDoneStateSize)
  1723.             THROW(errAECorruptData);
  1724.         
  1725.         Environment*    ev = somGetGlobalEnvironment();
  1726.         if (which == kUndo)
  1727.         {
  1728.             part->UndoAction(ev, data);
  1729.             error = ODGetSOMException(ev);
  1730.         }
  1731.         else if (which == kRedo)
  1732.         {
  1733.             part->RedoAction(ev, data);
  1734.             error = ODGetSOMException(ev);
  1735.         }
  1736.         else if (which == kDispose)
  1737.         {
  1738.             part->DisposeActionState(ev, data, doneState);
  1739.             error = ODGetSOMException(ev);
  1740.         }
  1741.         
  1742.         DisposeByteArray(data);
  1743.         
  1744.     CATCH_ALL
  1745.         error = ErrorCode();
  1746.     ENDTRY
  1747.  
  1748.     return error;
  1749. }
  1750.  
  1751. //------------------------------------------------------------------------------
  1752. // HandleUndoNotify                
  1753. //------------------------------------------------------------------------------
  1754.  
  1755. static pascal OSErr HandleUndoNotify(AppleEvent* message, AppleEvent* reply,
  1756.                                         long refCon)
  1757. {
  1758.     return HandleUndoOrRedoOrDisposeNotify(message, reply, refCon, kUndo);
  1759. }
  1760.  
  1761. //------------------------------------------------------------------------------
  1762. // HandleRedoNotify                
  1763. //------------------------------------------------------------------------------
  1764.  
  1765. static pascal OSErr HandleRedoNotify(AppleEvent* message, AppleEvent* reply,
  1766.                                         long refCon)
  1767. {
  1768.     return HandleUndoOrRedoOrDisposeNotify(message, reply, refCon, kRedo);
  1769. }
  1770.  
  1771. //------------------------------------------------------------------------------
  1772. // HandleDisposeNotify                
  1773. //------------------------------------------------------------------------------
  1774.  
  1775. static pascal OSErr HandleDisposeNotify(AppleEvent* message, AppleEvent* reply,
  1776.                                         long refCon)
  1777. {
  1778.     return HandleUndoOrRedoOrDisposeNotify(message, reply, refCon, kDispose);
  1779. }
  1780.  
  1781. //------------------------------------------------------------------------------
  1782. // ODUndo::InitUndo
  1783. //------------------------------------------------------------------------------
  1784.  
  1785. SOM_Scope void  SOMLINK ODUndoInitUndo(ODUndo *somSelf, Environment *ev)
  1786. {
  1787.     ODUndoData *somThis = ODUndoGetData(somSelf);
  1788.     ODUndoMethodDebug("ODUndo","ODUndoInitUndo");
  1789.  
  1790.     /* Moved from somInit. SOM itself sets fields to zero
  1791.     _fSystemUndo = kODNULL;
  1792.     */
  1793.  
  1794.     TRY
  1795.         somSelf->InitObject(ev);
  1796.  
  1797.         _fSystemUndo = GetSystemUndo();
  1798.         if (!_fSystemUndo)
  1799.         {
  1800.             _fSystemUndo = new (kODSystemHeap) SystemUndo();
  1801.             if (_fSystemUndo)
  1802.             {
  1803.                 _fSystemUndo->Initialize();
  1804.                 SetSystemUndo(_fSystemUndo);
  1805.             }
  1806.         }
  1807.         THROW_IF_ERROR(AEInstallEventHandler(kODShellSignature,
  1808.                                     kUndoNotifyID,
  1809.                                     NewAEEventHandlerProc(HandleUndoNotify),
  1810.                                     (long)somSelf, !kIsSysHandler));
  1811.         THROW_IF_ERROR(AEInstallEventHandler(kODShellSignature,
  1812.                                     kRedoNotifyID,
  1813.                                     NewAEEventHandlerProc(HandleRedoNotify),
  1814.                                     (long)somSelf, !kIsSysHandler));
  1815.         THROW_IF_ERROR(AEInstallEventHandler(kODShellSignature,
  1816.                                     kDisposeActionNotifyID,
  1817.                                     NewAEEventHandlerProc(HandleDisposeNotify),
  1818.                                     (long)somSelf, !kIsSysHandler));
  1819.         _fSystemUndo->AddClient(somSelf);
  1820.     CATCH_ALL
  1821.         ODDeleteObject(_fSystemUndo);
  1822.         ODSetSOMException(ev, ErrorCode());
  1823.     ENDTRY
  1824. }
  1825.  
  1826. //------------------------------------------------------------------------------
  1827. // ODUndo::~ODUndo
  1828. //------------------------------------------------------------------------------
  1829.  
  1830. SOM_Scope void  SOMLINK ODUndosomUninit(ODUndo *somSelf)
  1831. {
  1832.     ODUndoData *somThis = ODUndoGetData(somSelf);
  1833.     ODUndoMethodDebug("ODUndo","ODUndosomUninit");
  1834.  
  1835.     if (_fSystemUndo)
  1836.     {
  1837.         _fSystemUndo->RemoveClient(somSelf);
  1838.         
  1839.         if (_fSystemUndo->GetNumClients() == 0) // reclaim space.
  1840.         {
  1841.     //        WARN("Deleting system undo object.");
  1842.             ODDeleteObject(_fSystemUndo);
  1843.             SetSystemUndo(kODNULL);
  1844.         }
  1845.     }
  1846.     ODUndo_parents_somUninit(somSelf);
  1847. }
  1848. #if 0
  1849. //------------------------------------------------------------------------------
  1850. // ODUndo::Purge
  1851. //------------------------------------------------------------------------------
  1852.  
  1853. SOM_Scope ODSize  SOMLINK ODUndoPurge(ODUndo *somSelf, Environment *ev,
  1854.         ODSize size)
  1855. {
  1856.     ODUndoData *somThis = ODUndoGetData(somSelf);
  1857.     ODUndoMethodDebug("ODUndo","ODUndoPurge");
  1858.  
  1859.     ODSize purged = 0;
  1860.     ODVolatile(purged);
  1861.     
  1862.     SOM_TRY
  1863.         if (_fSystemUndo) {
  1864.             purged =  _fSystemUndo->Purge(size);
  1865.         }
  1866.         else
  1867.             purged =  0;
  1868.  
  1869.         purged += parent_Purge(somSelf,ev,size);
  1870.     SOM_CATCH_ALL
  1871.         WARN("Error %ld trying to purge in ODUndoPurge",ErrorCode());
  1872.         SetErrorCode(kODNoError);        // dh - Eat the exception; Purge should not 
  1873.                                         // propagate it because clients function
  1874.                                         // fine whether memory was purged or not.
  1875.     SOM_ENDTRY
  1876.  
  1877.     return purged;
  1878. }
  1879. #endif /* 0 */
  1880. //------------------------------------------------------------------------------
  1881. // ODUndo::AddActionToHistory
  1882. //------------------------------------------------------------------------------
  1883.  
  1884. SOM_Scope void  SOMLINK ODUndoAddActionToHistory(ODUndo *somSelf, Environment *ev,
  1885.         ODPart* whichPart,
  1886.         ODActionData* actionData,
  1887.         ODActionType actionType,
  1888.         ODName* undoActionLabel,
  1889.         ODName* redoActionLabel)
  1890. {
  1891.     ODUndoData *somThis = ODUndoGetData(somSelf);
  1892.     ODUndoMethodDebug("ODUndo","ODUndoAddActionToHistory");
  1893.  
  1894.     SOM_CATCH
  1895.         return;
  1896.  
  1897.     if (_fSystemUndo)
  1898.         _fSystemUndo->AddActionToHistory(whichPart, actionData, actionType,
  1899.                                         undoActionLabel, redoActionLabel);
  1900.     else
  1901.         THROW(kODErrOutOfMemory);
  1902. }
  1903.  
  1904. //------------------------------------------------------------------------------
  1905. // ODUndo::Undo
  1906. //------------------------------------------------------------------------------
  1907.  
  1908. SOM_Scope void  SOMLINK ODUndoUndo(ODUndo *somSelf, Environment *ev)
  1909. {
  1910.     ODUndoData *somThis = ODUndoGetData(somSelf);
  1911.     ODUndoMethodDebug("ODUndo","ODUndoUndo");
  1912.  
  1913.     SOM_CATCH
  1914.         return;
  1915.  
  1916.     if (_fSystemUndo)
  1917.         _fSystemUndo->Undo();
  1918.     else
  1919.         THROW(kODErrEmptyStack);
  1920. }
  1921.  
  1922. //------------------------------------------------------------------------------
  1923. // ODUndo::Redo
  1924. //------------------------------------------------------------------------------
  1925.  
  1926. SOM_Scope void  SOMLINK ODUndoRedo(ODUndo *somSelf, Environment *ev)
  1927. {
  1928.     ODUndoData *somThis = ODUndoGetData(somSelf);
  1929.     ODUndoMethodDebug("ODUndo","ODUndoRedo");
  1930.  
  1931.     SOM_CATCH
  1932.         return;
  1933.  
  1934.     if (_fSystemUndo)
  1935.         _fSystemUndo->Redo();
  1936.     else
  1937.         THROW(kODErrEmptyStack);
  1938. }
  1939.  
  1940. //------------------------------------------------------------------------------
  1941. // ODUndo::MarkActionHistory
  1942. //------------------------------------------------------------------------------
  1943.  
  1944. SOM_Scope void  SOMLINK ODUndoMarkActionHistory(ODUndo *somSelf, Environment *ev)
  1945. {
  1946.     ODUndoData *somThis = ODUndoGetData(somSelf);
  1947.     ODUndoMethodDebug("ODUndo","ODUndoMarkActionHistory");
  1948.  
  1949.     SOM_CATCH
  1950.         return;
  1951.  
  1952.     if (_fSystemUndo)
  1953.         _fSystemUndo->MarkActionHistory();
  1954.     else
  1955.         THROW(kODErrCannotMarkAction);
  1956. }
  1957.  
  1958. //------------------------------------------------------------------------------
  1959. // ODUndo::ClearActionHistory
  1960. //------------------------------------------------------------------------------
  1961.  
  1962. SOM_Scope void  SOMLINK ODUndoClearActionHistory(ODUndo *somSelf, Environment *ev,
  1963.         ODRespectMarksChoices respectMarks)
  1964. {
  1965.     ODUndoMethodDebug("ODUndo","ODUndoClearActionHistory");
  1966.     ODUndoData *somThis = ODUndoGetData(somSelf);
  1967.  
  1968.     SOM_CATCH
  1969.         return;
  1970.  
  1971.     if (_fSystemUndo)
  1972.         _fSystemUndo->ClearActionHistory(respectMarks);
  1973. }
  1974.  
  1975. //------------------------------------------------------------------------------
  1976. // ODUndo::ClearRedoHistory
  1977. //------------------------------------------------------------------------------
  1978.  
  1979. SOM_Scope void  SOMLINK ODUndoClearRedoHistory(ODUndo *somSelf, Environment *ev)
  1980. {
  1981.     ODUndoMethodDebug("ODUndo","ODUndoClearRedoHistory");
  1982.     ODUndoData *somThis = ODUndoGetData(somSelf);
  1983.  
  1984.     SOM_CATCH
  1985.         return;
  1986.  
  1987.     if (_fSystemUndo)
  1988.         _fSystemUndo->ClearRedoHistory();
  1989. }
  1990.  
  1991. //------------------------------------------------------------------------------
  1992. // ODUndo::PeekUndoHistory
  1993. //------------------------------------------------------------------------------
  1994.  
  1995. SOM_Scope ODBoolean  SOMLINK ODUndoPeekUndoHistory(ODUndo *somSelf, Environment *ev,
  1996.         ODPart** part,
  1997.         ODActionData* actionData,
  1998.         ODActionType* actionType,
  1999.         ODName* actionLabel)
  2000. {
  2001.     ODUndoMethodDebug("ODUndo","ODUndoPeekUndoHistory");
  2002.     ODUndoData *somThis = ODUndoGetData(somSelf);
  2003.  
  2004.     SOM_CATCH
  2005.         return kODFalse;
  2006.  
  2007.     if (_fSystemUndo)
  2008.         return _fSystemUndo->PeekUndoHistory(part, actionData, actionType,
  2009.                                                 actionLabel);
  2010.     else
  2011.         return kODFalse;
  2012. }
  2013.  
  2014. //------------------------------------------------------------------------------
  2015. // ODUndo::PeekRedoHistory
  2016. //------------------------------------------------------------------------------
  2017.  
  2018. SOM_Scope ODBoolean  SOMLINK ODUndoPeekRedoHistory(ODUndo *somSelf, Environment *ev,
  2019.         ODPart** part,
  2020.         ODActionData* actionData,
  2021.         ODActionType* actionType,
  2022.         ODName* actionLabel)
  2023. {
  2024.     ODUndoMethodDebug("ODUndo","ODUndoPeekRedoHistory");
  2025.     ODUndoData *somThis = ODUndoGetData(somSelf);
  2026.  
  2027.     SOM_CATCH
  2028.         return kODFalse;
  2029.  
  2030.     if (_fSystemUndo)
  2031.         return _fSystemUndo->PeekRedoHistory(part, actionData, actionType,
  2032.                                                 actionLabel);
  2033.     else
  2034.         return kODFalse;
  2035. }
  2036.  
  2037. //------------------------------------------------------------------------------
  2038. // ODUndo::AbortCurrentTransaction
  2039. //------------------------------------------------------------------------------
  2040.  
  2041. SOM_Scope void  SOMLINK ODUndoAbortCurrentTransaction(ODUndo *somSelf, Environment *ev)
  2042. {
  2043.     ODUndoMethodDebug("ODUndo","ODUndoAbortCurrentTransaction");
  2044.     ODUndoData *somThis = ODUndoGetData(somSelf);
  2045.  
  2046.     SOM_CATCH
  2047.         return;
  2048.  
  2049.     if (_fSystemUndo)
  2050.         _fSystemUndo->AbortCurrentTransaction();
  2051. }
  2052.  
  2053.